#include "dri_usart.h"
#include "dri_systick.h"
#include "dri_servo.h"

// USART6 的变量
char usart6_rx_buffer[20];
int usart6_rx_index = 0;

// USART2 的变量
char usart2_rx_buffer[20];
int usart2_rx_index = 0;

// 全局标志：起立命令收到
volatile uint8_t stand_command_received = 0;

void dri_usart6_init(void)
{
    GPIO_InitTypeDef   GPIO_InitStruct;
    USART_InitTypeDef  USART_InitStruct;
    NVIC_InitTypeDef   NVIC_InitStruct;
    
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);

    GPIO_PinAFConfig(GPIOG, GPIO_PinSource9, GPIO_AF_USART6);
    GPIO_PinAFConfig(GPIOG, GPIO_PinSource14, GPIO_AF_USART6);
    
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_14;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOG, &GPIO_InitStruct);
    
    USART_InitStruct.USART_BaudRate = 115200;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_InitStruct.USART_StopBits = USART_StopBits_1;
    USART_InitStruct.USART_Parity = USART_Parity_No;
    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART6, &USART_InitStruct);

    USART_ITConfig(USART6, USART_IT_RXNE, ENABLE);
    NVIC_InitStruct.NVIC_IRQChannel = USART6_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);
    USART_ClearFlag(USART6, USART_FLAG_TC);
    USART_Cmd(USART6, ENABLE);
    
    // 初始化接收缓冲区
    memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
    usart6_rx_index = 0;
}

void dri_usart2_init(void)
{
    GPIO_InitTypeDef   GPIO_InitStruct;
    USART_InitTypeDef  USART_InitStruct;
    NVIC_InitTypeDef   NVIC_InitStruct;
    
    // 使能 GPIOA 和 USART2 时钟
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

    // 配置 PA2 和 PA3 为 USART2 功能
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);
    
    // 初始化 GPIO
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;  // PA2(TX), PA3(RX)
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStruct);
    
    // 配置 USART2
    USART_InitStruct.USART_BaudRate = 115200;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_InitStruct.USART_StopBits = USART_StopBits_1;
    USART_InitStruct.USART_Parity = USART_Parity_No;
    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Init(USART2, &USART_InitStruct);

    // 使能接收中断
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    
    // 配置 NVIC：设置最高抢占优先级
    NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;  // 最高抢占优先级
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;         // 子优先级最高
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStruct);
    
    // 清除标志位并使能 USART2
    USART_ClearFlag(USART2, USART_FLAG_TC);
    USART_Cmd(USART2, ENABLE);
    
    // 初始化接收缓冲区
    memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
    usart2_rx_index = 0;
}

int fputc(int ch, FILE *f)
{
    // 默认使用 USART6 输出
    USART_SendData(USART6, ch);
    while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
    USART_ClearFlag(USART6, USART_FLAG_TC);
    return ch;
}

// USART2 专用的输出函数
void usart2_putc(char ch)
{
    USART_SendData(USART2, ch);
    while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
    USART_ClearFlag(USART2, USART_FLAG_TC);
	
}

void USART6_IRQHandler(void)
{
    char received_char = 0;
    if(USART_GetITStatus(USART6, USART_IT_RXNE))
    {    
        // 清除中断标志位
        USART_ClearITPendingBit(USART6, USART_IT_RXNE);
        
        // 读取接收到的字符
        received_char = USART_ReceiveData(USART6);
        
        // 回传接收到的字符
        USART_SendData(USART6, received_char);
        while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
        USART_ClearFlag(USART6, USART_FLAG_TC);
        
        // 处理接收到的字符
        if(usart6_rx_index < (sizeof(usart6_rx_buffer) - 1))
        {
            // 如果收到回车或换行符，处理命令
            if(received_char == '\r' || received_char == '\n')
            {
                usart6_rx_buffer[usart6_rx_index] = '\0'; // 确保字符串以null结尾
                
                // 处理命令
                if(strcmp(usart6_rx_buffer, "led_close") == 0)
                {
                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart6_rx_buffer, "led_open") == 0)
                {
                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart6_rx_buffer, "fan_open") == 0)
                {
                    GPIO_SetBits(GPIOC, GPIO_Pin_6);
                }
                else if(strcmp(usart6_rx_buffer, "fan_close") == 0)
                {
                    GPIO_ResetBits(GPIOC, GPIO_Pin_6);
                }
				else if(strcmp(usart6_rx_buffer, "beep_open") == 0)  // 修正：使用usart6_rx_buffer
                {
                    GPIOA->ODR |= 0x01<<15;				
                }
                else if(strcmp(usart6_rx_buffer, "beep_close") == 0) // 修正：使用usart6_rx_buffer
                {
                    GPIOA->ODR &=~(0x01<<15);
                }
                
                // 重置接收缓冲区和索引
                memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
                usart6_rx_index = 0;
            }
            else
            {
                // 存储接收到的字符
                usart6_rx_buffer[usart6_rx_index++] = received_char;
            }
        }
        else
        {
            // 缓冲区已满，重置
            memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
            usart6_rx_index = 0;
        }
    }
}

void USART2_IRQHandler(void)
{
    char received_char = 0;
    if(USART_GetITStatus(USART2, USART_IT_RXNE))
    {    
        // 清除中断标志位
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);
        
        // 读取接收到的字符
        received_char = USART_ReceiveData(USART2);
        
        // 回传接收到的字符
        usart2_putc(received_char);
        
        // 处理接收到的字符
        if(usart2_rx_index < (sizeof(usart2_rx_buffer) - 1))
        {
            // 如果收到回车或换行符，处理命令
            if(received_char == '\r' || received_char == '\n')
            {
                usart2_rx_buffer[usart2_rx_index] = '\0'; // 确保字符串以null结尾
                
                // 处理命令
                if(strcmp(usart2_rx_buffer, "led_close") == 0)
                {
                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart2_rx_buffer, "led_open") == 0)
                {
                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
                }
                else if(strcmp(usart2_rx_buffer, "fan_open") == 0)
                {
                    GPIO_SetBits(GPIOC, GPIO_Pin_6);
                }
                else if(strcmp(usart2_rx_buffer, "fan_close") == 0)
                {
                    GPIO_ResetBits(GPIOC, GPIO_Pin_6);
                }
				else if(strcmp(usart2_rx_buffer, "beep_open") == 0)
                {
                    GPIOA->ODR |= 0x01<<15;
                }
                else if(strcmp(usart2_rx_buffer, "beep_close") == 0)
                {
                    GPIOA->ODR &=~(0x01<<15);
                }
				else if(strcmp(usart2_rx_buffer, "forward") == 0)//前进
                {
                    // 注意：这里不再直接进入循环，而是在主循环中处理
                    // 但由于命令是通过中断接收，这里只设置标志或直接执行可能会影响中断响应
                    // 因此，建议在主循环中处理持续动作，但为了响应及时，我们保留在中断中处理
                    // 但为了能打断，我们在循环中添加标志检查
                    stand_command_received = 0; // 重置标志
                    while(1)
                    {
                        dog_walk_forward();
                        if(stand_command_received) break; // 检查起立标志
                    }
                }
				else if(strcmp(usart2_rx_buffer, "stand") == 0)//起立
                {
                    stand_command_received = 1; // 设置起立标志
                    dog_stand(); // 执行起立
                }
				else if(strcmp(usart2_rx_buffer, "sit") == 0)//坐下
                {
                    dog_sit();
                }
				else if(strcmp(usart2_rx_buffer, "lie") == 0)//卧下
                {
                    dog_lie();
                }
				else if(strcmp(usart2_rx_buffer, "backward") == 0)//后退
                {
                    stand_command_received = 0; // 重置标志
                    while(1)
                    {
                        dog_walk_backward();
                        if(stand_command_received) break; // 检查起立标志
                    }
                }
                
                // 重置接收缓冲区和索引
                memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
                usart2_rx_index = 0;
            }
            else
            {
                // 存储接收到的字符
                usart2_rx_buffer[usart2_rx_index++] = received_char;
            }
        }
        else
        {
            // 缓冲区已满，重置
            memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
            usart2_rx_index = 0;
        }
    }
}
//#include "dri_usart.h"
//#include "dri_systick.h"
//#include "dri_servo.h"
//// USART6 的变量
//char usart6_rx_buffer[20];
//int usart6_rx_index = 0;

//// USART2 的变量
//char usart2_rx_buffer[20];
//int usart2_rx_index = 0;

//void dri_usart6_init(void)
//{
//    GPIO_InitTypeDef   GPIO_InitStruct;
//    USART_InitTypeDef  USART_InitStruct;
//    NVIC_InitTypeDef   NVIC_InitStruct;
//    
//    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
//    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);

//    GPIO_PinAFConfig(GPIOG, GPIO_PinSource9, GPIO_AF_USART6);
//    GPIO_PinAFConfig(GPIOG, GPIO_PinSource14, GPIO_AF_USART6);
//    
//    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
//    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_14;
//    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
//    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
//    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
//    GPIO_Init(GPIOG, &GPIO_InitStruct);
//    
//    USART_InitStruct.USART_BaudRate = 115200;
//    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
//    USART_InitStruct.USART_StopBits = USART_StopBits_1;
//    USART_InitStruct.USART_Parity = USART_Parity_No;
//    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
//    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//    USART_Init(USART6, &USART_InitStruct);

//    USART_ITConfig(USART6, USART_IT_RXNE, ENABLE);
//    NVIC_InitStruct.NVIC_IRQChannel = USART6_IRQn;
//    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
//    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
//    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
//    NVIC_Init(&NVIC_InitStruct);
//    USART_ClearFlag(USART6, USART_FLAG_TC);
//    USART_Cmd(USART6, ENABLE);
//    
//    // 初始化接收缓冲区
//    memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
//    usart6_rx_index = 0;
//}

//void dri_usart2_init(void)
//{
//    GPIO_InitTypeDef   GPIO_InitStruct;
//    USART_InitTypeDef  USART_InitStruct;
//    NVIC_InitTypeDef   NVIC_InitStruct;
//    
//    // 使能 GPIOA 和 USART2 时钟
//    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
//    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

//    // 配置 PA2 和 PA3 为 USART2 功能
//    GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
//    GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);
//    
//    // 初始化 GPIO
//    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
//    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;  // PA2(TX), PA3(RX)
//    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
//    GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
//    GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
//    GPIO_Init(GPIOA, &GPIO_InitStruct);
//    
//    // 配置 USART2
//    USART_InitStruct.USART_BaudRate = 115200;
//    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
//    USART_InitStruct.USART_StopBits = USART_StopBits_1;
//    USART_InitStruct.USART_Parity = USART_Parity_No;
//    USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
//    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//    USART_Init(USART2, &USART_InitStruct);

//    // 使能接收中断
//    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
//    
//    // 配置 NVIC
//    NVIC_InitStruct.NVIC_IRQChannel = USART2_IRQn;
//    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
//    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 2;  // 优先级与USART6不同
//    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
//    NVIC_Init(&NVIC_InitStruct);
//    
//    // 清除标志位并使能 USART2
//    USART_ClearFlag(USART2, USART_FLAG_TC);
//    USART_Cmd(USART2, ENABLE);
//    
//    // 初始化接收缓冲区
//    memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
//    usart2_rx_index = 0;
//}

//int fputc(int ch, FILE *f)
//{
//    // 默认使用 USART6 输出
//    USART_SendData(USART6, ch);
//    while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
//    USART_ClearFlag(USART6, USART_FLAG_TC);
//    return ch;
//}

//// USART2 专用的输出函数
//void usart2_putc(char ch)
//{
//    USART_SendData(USART2, ch);
//    while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
//    USART_ClearFlag(USART2, USART_FLAG_TC);
//	
//}

//void USART6_IRQHandler(void)
//{
//    char received_char = 0;
//    if(USART_GetITStatus(USART6, USART_IT_RXNE))
//    {    
//        // 清除中断标志位
//        USART_ClearITPendingBit(USART6, USART_IT_RXNE);
//        
//        // 读取接收到的字符
//        received_char = USART_ReceiveData(USART6);
//        
//        // 回传接收到的字符
//        USART_SendData(USART6, received_char);
//        while(USART_GetFlagStatus(USART6, USART_FLAG_TC) == RESET);
//        USART_ClearFlag(USART6, USART_FLAG_TC);
//        
//        // 处理接收到的字符
//        if(usart6_rx_index < (sizeof(usart6_rx_buffer) - 1))
//        {
//            // 如果收到回车或换行符，处理命令
//            if(received_char == '\r' || received_char == '\n')
//            {
//                usart6_rx_buffer[usart6_rx_index] = '\0'; // 确保字符串以null结尾
//                
//                // 处理命令
//                if(strcmp(usart6_rx_buffer, "led_close") == 0)
//                {
//                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
//                }
//                else if(strcmp(usart6_rx_buffer, "led_open") == 0)
//                {
//                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
//                }
//                else if(strcmp(usart6_rx_buffer, "fan_open") == 0)
//                {
//                    GPIO_SetBits(GPIOC, GPIO_Pin_6);
//                }
//                else if(strcmp(usart6_rx_buffer, "fan_close") == 0)
//                {
//                    GPIO_ResetBits(GPIOC, GPIO_Pin_6);
//                }
//				else if(strcmp(usart2_rx_buffer, "beep_open") == 0)
//                {
//                    GPIOA->ODR |= 0x01<<15;				
//                }
//                else if(strcmp(usart2_rx_buffer, "beep_close") == 0)
//                {
//                    GPIOA->ODR &=~(0x01<<15);
//					
//                }
//                
//                // 重置接收缓冲区和索引
//                memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
//                usart6_rx_index = 0;
//            }
//            else
//            {
//                // 存储接收到的字符
//                usart6_rx_buffer[usart6_rx_index++] = received_char;
//            }
//        }
//        else
//        {
//            // 缓冲区已满，重置
//            memset(usart6_rx_buffer, 0, sizeof(usart6_rx_buffer));
//            usart6_rx_index = 0;
//        }
//    }
//}
//int stand = 0;
//void USART2_IRQHandler(void)
//{
//    char received_char = 0;
//    if(USART_GetITStatus(USART2, USART_IT_RXNE))
//    {    
//        // 清除中断标志位
//        USART_ClearITPendingBit(USART2, USART_IT_RXNE);
//        
//        // 读取接收到的字符
//        received_char = USART_ReceiveData(USART2);
//        
//        // 回传接收到的字符
//        usart2_putc(received_char);
//        
//        // 处理接收到的字符
//        if(usart2_rx_index < (sizeof(usart2_rx_buffer) - 1))
//        {
//            // 如果收到回车或换行符，处理命令
//            if(received_char == '\r' || received_char == '\n')
//            {
//                usart2_rx_buffer[usart2_rx_index] = '\0'; // 确保字符串以null结尾
//                
//                // 处理命令
//                if(strcmp(usart2_rx_buffer, "led_close") == 0)
//                {
//                    GPIO_SetBits(GPIOF, GPIO_Pin_8);
//                }
//                else if(strcmp(usart2_rx_buffer, "led_open") == 0)
//                {
//                    GPIO_ResetBits(GPIOF, GPIO_Pin_8);
//                }
//                else if(strcmp(usart2_rx_buffer, "fan_open") == 0)
//                {
//                    GPIO_SetBits(GPIOC, GPIO_Pin_6);
//					
//                }
//                else if(strcmp(usart2_rx_buffer, "fan_close") == 0)
//                {
//                    GPIO_ResetBits(GPIOC, GPIO_Pin_6);
//					
//                }
//				else if(strcmp(usart2_rx_buffer, "beep_open") == 0)
//                {
//                    GPIOA->ODR |= 0x01<<15;
//					
//                }
//                else if(strcmp(usart2_rx_buffer, "beep_close") == 0)
//                {
//                    GPIOA->ODR &=~(0x01<<15);
//					
//                }
//				
//				else if(strcmp(usart2_rx_buffer, "forward") == 0)//前进
//                {
//					stand = 0;
//					while(1)
//					{
//						
//					dog_walk_forward();
//						if(stand==1) break;
//					}
//                }
//				else if(strcmp(usart2_rx_buffer, "stand") == 0)//起立
//                {
//					stand=1;
//						dog_stand();
//					
//					
//                }
//				else if(strcmp(usart2_rx_buffer, "sit") == 0)//坐下
//                {
//					stand=1;
//						dog_sit();
//					
//					
//                }
//				else if(strcmp(usart2_rx_buffer, "lie") == 0)//卧下
//                {
//					stand=1;
//						dog_lie();
//					
//                }
//				
//				else if(strcmp(usart2_rx_buffer, "backward") == 0)//后退
//                {
//					stand = 0;
//					while(1)
//					{
//					dog_walk_backward();
//						if(stand) break;
//					}
//                }
//                
//                // 重置接收缓冲区和索引
//                memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
//                usart2_rx_index = 0;
//            }
//            else
//            {
//                // 存储接收到的字符
//                usart2_rx_buffer[usart2_rx_index++] = received_char;
//            }
//        }
//        else
//        {
//            // 缓冲区已满，重置
//            memset(usart2_rx_buffer, 0, sizeof(usart2_rx_buffer));
//            usart2_rx_index = 0;
//        }
//    }
//}
